home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / ghost / gs403src_gs.lha / gs4.03 / gsiodev.c < prev    next >
C/C++ Source or Header  |  1996-06-25  |  7KB  |  266 lines
  1. /* Copyright (C) 1993, 1994, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsiodev.c */
  20. /* IODevice implementation for Ghostscript */
  21. #include "errno_.h"
  22. #include "string_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gp.h"
  26. #include "gsparam.h"
  27. #include "gxiodev.h"
  28.  
  29. /* Import the IODevice table from gconfig.c. */
  30. extern gx_io_device *gx_io_device_table[];
  31. extern uint gx_io_device_table_count;
  32.  
  33. /* Define the OS (%os%) device. */
  34. iodev_proc_fopen(iodev_os_fopen);
  35. iodev_proc_fclose(iodev_os_fclose);
  36. private iodev_proc_delete_file(os_delete);
  37. private iodev_proc_rename_file(os_rename);
  38. private iodev_proc_file_status(os_status);
  39. private iodev_proc_enumerate_files(os_enumerate);
  40. private iodev_proc_get_params(os_get_params);
  41. gx_io_device gs_iodev_os = {
  42.     "%os%", "FileSystem",
  43.     { iodev_no_init, iodev_no_open_device,
  44.       NULL /*iodev_os_open_file*/, iodev_os_fopen, iodev_os_fclose,
  45.       os_delete, os_rename, os_status,
  46.       os_enumerate, gp_enumerate_files_next, gp_enumerate_files_close,
  47.       os_get_params, iodev_no_put_params
  48.     }
  49. };
  50.  
  51. /* ------ Initialization ------ */
  52.  
  53. void
  54. gs_iodev_init(gs_memory_t *mem)
  55. {    /* Run the one-time initialization of each IODevice. */
  56.     gx_io_device **piodev = &gx_io_device_table[0];
  57.     for ( ; *piodev; piodev++ )
  58.         ((*piodev)->procs.init)(*piodev, mem);
  59. }
  60.  
  61. /* ------ Default (unimplemented) IODevice procedures ------ */
  62.  
  63. int
  64. iodev_no_init(gx_io_device *iodev, gs_memory_t *mem)
  65. {    return 0;
  66. }
  67.  
  68. int
  69. iodev_no_open_device(gx_io_device *iodev, const char *access, stream **ps,
  70.   gs_memory_t *mem)
  71. {    return_error(gs_error_invalidfileaccess);
  72. }
  73.  
  74. int
  75. iodev_no_open_file(gx_io_device *iodev, const char *fname, uint namelen,
  76.   const char *access, stream **ps, gs_memory_t *mem)
  77. {    return_error(gs_error_invalidfileaccess);
  78. }
  79.  
  80. int
  81. iodev_no_fopen(gx_io_device *iodev, const char *fname, const char *access,
  82.   FILE **pfile, char *rfname, uint rnamelen)
  83. {    return_error(gs_error_invalidfileaccess);
  84. }
  85.  
  86. int
  87. iodev_no_fclose(gx_io_device *iodev, FILE *file)
  88. {    return_error(gs_error_ioerror);
  89. }
  90.  
  91. int
  92. iodev_no_delete_file(gx_io_device *iodev, const char *fname)
  93. {    return_error(gs_error_invalidfileaccess);
  94. }
  95.  
  96. int
  97. iodev_no_rename_file(gx_io_device *iodev, const char *from, const char *to)
  98. {    return_error(gs_error_invalidfileaccess);
  99. }
  100.  
  101. int
  102. iodev_no_file_status(gx_io_device *iodev, const char *fname, struct stat *pstat)
  103. {    return_error(gs_error_undefinedfilename);
  104. }
  105.  
  106. file_enum *
  107. iodev_no_enumerate_files(gx_io_device *iodev, const char *pat, uint patlen,
  108.   gs_memory_t *memory)
  109. {    return NULL;
  110. }
  111.  
  112. int
  113. iodev_no_get_params(gx_io_device *iodev, gs_param_list *plist)
  114. {    return 0;
  115. }
  116.  
  117. int
  118. iodev_no_put_params(gx_io_device *iodev, gs_param_list *plist)
  119. {    return param_commit(plist);
  120. }
  121.  
  122. /* ------ %os% ------ */
  123.  
  124. /* The fopen routine is exported for %null. */
  125. int
  126. iodev_os_fopen(gx_io_device *iodev, const char *fname, const char *access,
  127.   FILE **pfile, char *rfname, uint rnamelen)
  128. {    errno = 0;
  129.     *pfile = gp_fopen(fname, access);
  130.     if ( *pfile == NULL )
  131.       return_error(gs_fopen_errno_to_code(errno));
  132.     if ( rfname != NULL )
  133.       strcpy(rfname, fname);
  134.     return 0;
  135. }
  136.  
  137. /* The fclose routine is exported for %null. */
  138. int
  139. iodev_os_fclose(gx_io_device *iodev, FILE *file)
  140. {    fclose(file);
  141.     return 0;
  142. }
  143.  
  144. private int
  145. os_delete(gx_io_device *iodev, const char *fname)
  146. {    return (unlink(fname) == 0 ? 0 : gs_error_ioerror);
  147. }
  148.  
  149. private int
  150. os_rename(gx_io_device *iodev, const char *from, const char *to)
  151. {    return (rename(from, to) == 0 ? 0 : gs_error_ioerror);
  152. }
  153.  
  154. private int
  155. os_status(gx_io_device *iodev, const char *fname, struct stat *pstat)
  156. {    /* The RS/6000 prototype for stat doesn't include const, */
  157.     /* so we have to explicitly remove the const modifier. */
  158.     return (stat((char *)fname, pstat) < 0 ? gs_error_undefinedfilename : 0);
  159. }
  160.  
  161. private file_enum *
  162. os_enumerate(gx_io_device *iodev, const char *pat, uint patlen,
  163.   gs_memory_t *mem)
  164. {    return gp_enumerate_files_init(pat, patlen, mem);
  165. }
  166.  
  167. private int
  168. os_get_params(gx_io_device *iodev, gs_param_list *plist)
  169. {    /* We aren't going to implement *all* of the Adobe parameters.... */
  170.     int code;
  171.     bool btrue = true;
  172.  
  173.     if ( (code = param_write_bool(plist, "HasNames", &btrue)) < 0 )
  174.       return code;
  175.     return 0;
  176. }
  177.  
  178. /* ------ Utilities ------ */
  179.  
  180. /* Get the N'th IODevice from the known device table. */
  181. gx_io_device *
  182. gs_getiodevice(int index)
  183. {    if ( index < 0 || index >= gx_io_device_table_count )
  184.         return 0;        /* index out of range */
  185.     return gx_io_device_table[index];
  186. }
  187.  
  188. /* Look up an IODevice name. */
  189. /* The name may be either %device or %device%. */
  190. gx_io_device *
  191. gs_findiodevice(const byte *str, uint len)
  192. {    gx_io_device **pftab;
  193.     if ( len > 1 && str[len - 1] == '%' )
  194.       len--;
  195.     for ( pftab = gx_io_device_table; *pftab != NULL; pftab++ )
  196.       { const char *dname = (*pftab)->dname;
  197.         if ( strlen(dname) == len + 1 && !memcmp(str, dname, len) )
  198.           return *pftab;
  199.       }
  200.     return 0;
  201. }
  202.  
  203. /* ------ Accessors ------ */
  204.  
  205. /* Get IODevice parameters. */
  206. int
  207. gs_getdevparams(gx_io_device *iodev, gs_param_list *plist)
  208. {    /* All IODevices have the Type parameter. */
  209.     gs_param_string ts;
  210.     int code;
  211.  
  212.     param_string_from_string(ts, iodev->dtype);
  213.     code = param_write_name(plist, "Type", &ts);
  214.     if ( code < 0 )
  215.       return code;
  216.     return (*iodev->procs.get_params)(iodev, plist);
  217. }
  218.  
  219. /* Put IODevice parameters. */
  220. int
  221. gs_putdevparams(gx_io_device *iodev, gs_param_list *plist)
  222. {    return (*iodev->procs.put_params)(iodev, plist);
  223. }
  224.  
  225. /* Convert an OS error number to a PostScript error */
  226. /* if opening a file fails. */
  227. int
  228. gs_fopen_errno_to_code(int eno)
  229. {    /* Different OSs vary widely in their error codes. */
  230.     /* We try to cover as many variations as we know about. */
  231.     switch ( eno )
  232.       {
  233. #ifdef ENOENT
  234.       case ENOENT:
  235.         return_error(gs_error_undefinedfilename);
  236. #endif
  237. #ifdef ENOFILE
  238. #  ifndef ENOENT
  239. #    define ENOENT ENOFILE
  240. #  endif
  241. #  if ENOFILE != ENOENT
  242.       case ENOFILE:
  243.         return_error(gs_error_undefinedfilename);
  244. #  endif
  245. #endif
  246. #ifdef ENAMETOOLONG
  247.       case ENAMETOOLONG:
  248.         return_error(gs_error_undefinedfilename);
  249. #endif
  250. #ifdef EACCES
  251.       case EACCES:
  252.         return_error(gs_error_invalidfileaccess);
  253. #endif
  254. #ifdef EMFILE
  255.       case EMFILE:
  256.         return_error(gs_error_limitcheck);
  257. #endif
  258. #ifdef ENFILE
  259.       case ENFILE:
  260.         return_error(gs_error_limitcheck);
  261. #endif
  262.       default:
  263.         return_error(gs_error_ioerror);
  264.       }
  265. }
  266.